// musicScanner.ts
// 导入文件系统模块，用于文件和目录操作
import fs from "fs";
// 导入路径处理模块，用于处理文件和目录路径
import path from "path";
// 导入NodeID3库，用于读取和写入MP3文件的ID3标签
import NodeID3 from "node-id3";
// 导入util模块的promisify函数，将回调风格的函数转换为Promise风格
import { promisify } from "util";

// 将fs.readdir转换为Promise版本，用于异步读取目录内容
const readdir = promisify(fs.readdir);
// 将fs.stat转换为Promise版本，用于异步获取文件/目录状态信息
const stat = promisify(fs.stat);

// 定义歌曲信息接口
interface Song {
  id: string; // 歌曲唯一标识符
  title: string; // 歌曲标题
  artist: string; // 艺术家名称
  album: string; // 专辑名称
  duration: number; // 歌曲时长（秒）
  url: string; // 歌曲文件路径
  cover?: string; // 可选：封面图片的Base64数据或URL
  lyrics?: string; // 歌词内容（可选）
}

// 扫描音乐目录的函数，返回歌曲信息的Promise数组
export async function scanMusicDirectory(dirPath: string): Promise<Song[]> {
  // 初始化空数组存储扫描到的歌曲
  const songs: Song[] = [];
  // 计数器，用于生成歌曲ID
  let idCounter = 1;

  // 定义递归遍历目录的内部函数
  async function traverseDirectory(currentPath: string) {
    try {
      // 读取当前目录下的所有文件和子目录
      const files = await readdir(currentPath);

      // 遍历当前目录下的每个文件/目录
      for (const file of files) {
        // 拼接完整路径
        const fullPath = path.join(currentPath, file);
        // 获取文件/目录的状态信息
        const stats = await stat(fullPath);

        // 如果是目录，则递归遍历
        if (stats.isDirectory()) {
          await traverseDirectory(fullPath);
        }
        // 如果是MP3文件（忽略大小写）
        else if (path.extname(file).toLowerCase() === ".mp3") {
          try {
            // 读取MP3文件的ID3标签
            const tags = await NodeID3.read(fullPath);
            // 提取文件名（不含扩展名）
            const fileName = path.basename(file, ".mp3");

            // 处理时长：如果无法解析或无效，默认180秒
            let duration = 180;

            // 方法 1: 从 ID3 标签获取（如果有）
            if (tags.length && !isNaN(Number(tags.length))) {
              duration = Math.floor(Number(tags.length));
            }
            // 方法 2: 从文件状态获取（不太准确但作为备用）
            else {
              // 计算基于文件大小的近似时长（128kbps MP3）
              // 公式：文件大小(字节) / (128 * 1000 / 8) = 秒数
              const fileSizeMB = stats.size / (1024 * 1024);
              duration = Math.floor((fileSizeMB * 8 * 1024) / 128);

              // 确保时长在合理范围内
              duration = Math.max(30, Math.min(duration, 1200)); // 30秒到20分钟之间
            }

            // 处理封面图片转换
            let coverBase64: string | undefined = undefined;

            if (tags.image) {
              // 处理不同类型的图像数据
              if (typeof tags.image === "string") {
                // 如果已经是字符串（可能是base64）
                coverBase64 = tags.image;
              } else if (Buffer.isBuffer(tags.image)) {
                // 如果是 Buffer 类型
                coverBase64 = `data:image/jpeg;base64,${tags.image.toString(
                  "base64"
                )}`;
              } else if (
                tags.image.imageBuffer &&
                Buffer.isBuffer(tags.image.imageBuffer)
              ) {
                // 如果是对象包含 imageBuffer
                const mime = tags.image.mime || "image/jpeg";
                coverBase64 = `data:${mime};base64,${tags.image.imageBuffer.toString(
                  "base64"
                )}`;
              } else {
                // 从 raw 数据中提取封面（备用方法）
                // 尝试从 raw 对象中查找 APIC 类型的封面数据（支持带扩展名的键如 "APIC:cover.jpg"）
                const apicKey = Object.keys(tags.raw || {}).find((key) =>
                  key.startsWith("APIC")
                );
                if (
                  apicKey &&
                  typeof tags.raw === "object" &&
                  apicKey in tags.raw &&
                  // 类型断言确保该属性具有 imageBuffer
                  (tags.raw as Record<string, any>)[apicKey]?.imageBuffer
                ) {
                  const mime =
                    (tags.raw as Record<string, any>)[apicKey].mime ||
                    "image/jpeg";
                  coverBase64 = `data:${mime};base64,${(
                    tags.raw as Record<string, any>
                  )[apicKey].imageBuffer.toString("base64")}`;
                }
              }
            }

            // 歌词存储在 <音乐目录>/lrc/ 下
            const lrcDir = path.join(dirPath, "lrc");
            // 构建歌词文件名：使用歌曲标题或文件名 + .lrc 扩展名
            const lrcFileName = `${fileName}.lrc`;
            // 完整歌词路径
            const lyricsPath = path.join(lrcDir, lrcFileName);
            
            // 读取歌词文件内容（如果存在）
            let lyricsContent: string | undefined = undefined;
            try {
              if (fs.existsSync(lyricsPath)) {
                lyricsContent = await fs.promises.readFile(lyricsPath, 'utf-8');
              }
            } catch (error) {
              console.warn(`读取歌词文件失败: ${lyricsPath}`, error);
            }

            console.log(fileName, "歌词", '\n', lyricsContent)

            // 将歌曲信息添加到数组
            songs.push({
              id: (idCounter++).toString(), // 生成唯一ID并递增计数器
              title: tags.title || fileName, // 使用标签中的标题或文件名
              artist: tags.artist || "未知艺术家", // 使用标签中的艺术家或默认值
              album: tags.album || "未知专辑", // 使用标签中的专辑或默认值
              duration: duration, // 歌曲时长
              url: fullPath, // 使用完整文件系统路径
              lyrics: lyricsContent, // 存储歌词歌词
              // 处理封面图片
              cover: coverBase64,
              // tags.image
              //   ? // 检查封面是否存在且是对象（包含图像数据）
              //     typeof tags.image === "object" && tags.image.imageBuffer
              //     ? // 将图像缓冲区转换为Base64数据URL
              //       `data:image/jpeg;base64,${tags.image.imageBuffer.toString("base64")}`
              //     : undefined // 如果没有有效图像数据，设为undefined
              //   : undefined // 如果没有封面，设为undefined
            });
          } catch (error) {
            // 处理单个文件解析错误
            console.error(`解析文件失败: ${fullPath}`, error);
          }
        }
      }
    } catch (error) {
      // 处理目录遍历错误
      console.error(`遍历目录失败: ${currentPath}`, error);
    }
  }

  // 从根目录开始递归遍历
  await traverseDirectory(dirPath);
  // 返回所有扫描到的歌曲
  return songs;
}
